home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’96 / Talking Telnet / source / Sets / Sets.c next >
Text File  |  1996-06-22  |  22KB  |  797 lines
  1. /*
  2. *    Sets.c
  3. *    All code relating to loading, parsing, and saving of sets
  4. *
  5. *****************************************************************
  6. *    NCSA Telnet for the Macintosh                                *
  7. *                                                                *
  8. *    National Center for Supercomputing Applications                *
  9. *    Software Development Group                                    *
  10. *    152 Computing Applications Building                            *
  11. *    605 E. Springfield Ave.                                        *
  12. *    Champaign, IL  61820                                        *
  13. *                                                                *
  14. *    Copyright (c) 1986-1993,                                    *
  15. *    Board of Trustees of the University of Illinois                *
  16. *****************************************************************
  17. *  Revisions:
  18. *  7/92        Telnet 2.6:    Code moved here from config.c and maclook.c...  Jim Browne
  19. */
  20.  
  21. #ifdef MPW
  22. #pragma segment Files
  23. #endif
  24.  
  25.  
  26. #include "macros.proto.h"
  27. #include "wind.h"            /* For WindRec definition */
  28. #include "Sets.proto.h"
  29. #include "telneterrors.h"
  30. #include "prefs.proto.h"
  31. #include "Connections.proto.h"
  32. #include "rsinterf.proto.h"
  33. #include "vsdata.h"
  34. #include "vsinterf.proto.h"
  35.  
  36. //#define    DEBUG_SETS
  37. #ifdef    DEBUG_SETS
  38. #define    sets_debug_print(x) putln(x)
  39. #else
  40. #define sets_debug_print(x)
  41. #endif
  42.  
  43. ConnInitParams    **SetParams;
  44. SessionPrefs    *SetSessionPtr;
  45. TerminalPrefs    *SetTerminalPtr;
  46.  
  47. char            *Cspace;
  48.  
  49. extern WindRec
  50.     *screens;        /* Window Records (VS) for :    Current Sessions */
  51.  
  52.  
  53. extern MenuHandle
  54.     myMenus[NMENUS];        /* Menu Handles .... */
  55.  
  56. #define PORTNUM 37            /* NCSA 2.5: the port variable */
  57.  
  58. void    SETSunload(void)    {}
  59.  
  60. /* affirmative() checks a token to see if it is a valid Affirmation string.
  61.     We now get the affirmative strings from the resource */
  62.     
  63. Boolean    affirmative( char *s)
  64. {
  65.     short    i;
  66.     Str255    AffWords;        /* Telnet 2.6: get string resources */
  67.  
  68.     for (i=0; i<TelInfo->position; i++)
  69.                 s[i] = tolower(s[i]);
  70.  
  71.     for (i=1; i<= AFF_WORDS_COUNT ;i++) 
  72.         {
  73.         GetIndString(AffWords,AFF_WORDS_ID,i);
  74.         p2cstr(AffWords);
  75.         if (!ncstrcmp((char *)AffWords,s))                
  76.         break;                                        
  77.         }
  78.         
  79.     if (i <= AFF_WORDS_COUNT)
  80.         return(TRUE);
  81.     else
  82.         return(FALSE);
  83. }
  84.  
  85. /**************************************************************************/
  86. /*  Sissep
  87. *   is the character a valid separator for the hosts file?
  88. *   separators are white space, special chars and :;=
  89. *
  90. */
  91. Boolean Sissep( char c)
  92. {
  93.     if (c < 33)
  94.         return(1);
  95.     if (c == ':' || c == ';' || c == '=')
  96.         return(TRUE);
  97.     return(FALSE);
  98. }
  99.  
  100. /************************************************************************/
  101. /*  ncstrcmp
  102. *   No case string compare.
  103. *   Only returns 0=match, 1=no match, does not compare greater or less
  104. *   There is a tiny bit of overlap with the | 32 trick, but shouldn't be
  105. *   a problem.  It causes some different symbols to match.
  106. */
  107. short ncstrcmp(char *sa, char *sb)
  108. {
  109.     while (*sa && *sa < 33)        /* don't compare leading spaces */
  110.         sa++;
  111.     while (*sb && *sb < 33)
  112.         sb++;
  113.  
  114.     while (*sa && *sb) {
  115.         if ((*sa != *sb) && ((*sa | 32) != (*sb | 32)))
  116.             return(1);
  117.         sa++;sb++;
  118.     }
  119.     if (!*sa && !*sb)        /* if both at end of string */
  120.         return(0);
  121.     else
  122.         return(1);
  123. }
  124.  
  125. /* confile() now gets all of its keywords from the string resources, for greater
  126.     ease, flexibility, and overall coolness.  */
  127. short confile( char *s)
  128. {
  129.     short        i, port;
  130.     Boolean        success;
  131.     unsigned    int a,b,c,d;
  132.     int            signedint;
  133.     Str255        Ckeyw;
  134.     char        tempCstring[256];
  135.     sets_debug_print(s);
  136.     if (!(*s) )
  137.         return(0);
  138.  
  139.     switch( TelInfo->CONFstate) {
  140.         case 0:                /* No keyword yet! */
  141.             for (i=0; i<TelInfo->position; i++)
  142.                 s[i] = tolower(s[i]);
  143.             for (i=1; i<= SAVE_SET_STRINGS_COUNT ;i++) 
  144.                 {
  145.                 GetIndString(Ckeyw,SAVE_SET_STRINGS_ID,i);
  146.                 p2cstr(Ckeyw);
  147.                 if (!ncstrcmp((char *)Ckeyw,s))                
  148.                 break;                                        
  149.                 }
  150.  
  151.             if ( i > SAVE_SET_STRINGS_COUNT ) 
  152.                 {
  153.                 OperationFailedAlert(BAD_SET_ERR, 0, 0);
  154.                 return(1);
  155.                 }
  156.  
  157.             TelInfo->CONFstate=i;
  158.  
  159.             if (TelInfo->CONFstate==5) {
  160.                 SetSessionPtr->bksp = 0;
  161.                 TelInfo->CONFstate=0;
  162.                 }
  163.             if (TelInfo->CONFstate==6) {
  164.                 SetSessionPtr->bksp = 1;
  165.                 TelInfo->CONFstate=0;
  166.                 }
  167.             break;
  168.  
  169.         case 1:                /* NAME */
  170.             { char *p;
  171.             if (NULL == (p = myNewPtr(40000)))         /* is there enough memory? */
  172.                 {                    /* NOT enough memory for the set! */
  173.                 DoError(107 | MEMORY_ERRORCLASS, LEVEL2, NULL);    /* register the error */
  174.                 return(-1);
  175.                 }
  176.             else
  177.                 DisposPtr(p);
  178.             }
  179.             if (TelInfo->CONFactive) {
  180.                 success = CreateConnectionFromParams(SetParams);
  181.                 SetParams = NULL;
  182.                 if (!success) {
  183.                     sets_debug_print("ERROR IN OPENING!! ");
  184.                     return(42);
  185.                     }
  186.                 }
  187.  
  188.             if (SetParams == NULL) {
  189.                 SetParams = ReturnDefaultConnInitParams();
  190.                 HLockHi((Handle)SetParams);
  191.                 HLockHi((Handle)(**SetParams).session);
  192.                 SetSessionPtr = *(**SetParams).session;
  193.                 HLockHi((Handle)(**SetParams).terminal);
  194.                 SetTerminalPtr = *(**SetParams).terminal;
  195.                 }
  196.                 
  197.             strncpy(tempCstring, s, 255);            /* Move name in */
  198.             CtoPstr(tempCstring);
  199.             BlockMove(tempCstring, (**SetParams).WindowName, tempCstring[0]+1);
  200.             TelInfo->CONFstate=0;
  201.             TelInfo->CONFactive=1;
  202.             break;
  203.  
  204.         case 2:                /* HOST */
  205.             strncpy(tempCstring, s, 63);            /* Move name in */
  206.             CtoPstr(tempCstring);
  207.  
  208.             //    Process the hosname string.
  209.             if (ProcessHostnameString((StringPtr)tempCstring, &port))
  210.                 SetSessionPtr->port = port;
  211.             
  212.             BlockMove(tempCstring, SetSessionPtr->hostname, tempCstring[0]+1);
  213.  
  214.             TelInfo->CONFstate=0;
  215.             break;
  216.  
  217.         case 3:                /* SIZE */
  218.             if ( 4 != sscanf(s, "{%d,%d,%d,%d}", &a, &b, &c,&d) ) {
  219.                 sets_debug_print("Error in window size");
  220.                 return(2);
  221.                 }
  222.             
  223.             (**SetParams).WindowLocation.top=a;
  224.             (**SetParams).WindowLocation.left=b;
  225.             (**SetParams).WindowLocation.bottom=c;
  226.             (**SetParams).WindowLocation.right=d;
  227.             TelInfo->CONFstate=0;
  228.             break;
  229.  
  230.         case 4:
  231.             if ( 1 != sscanf(s,"%d", &a) ) {
  232.                 sets_debug_print("Scrollback needs parameter");
  233.                 return(1);
  234.                 }
  235.             SetTerminalPtr->numbkscroll = a;
  236.             TelInfo->CONFstate=0;
  237.             break;
  238.  
  239.         case 5:
  240.             SetSessionPtr->bksp = 0;            
  241.             TelInfo->CONFstate=0;
  242.             break;
  243.  
  244.         case 6:
  245.             SetSessionPtr->bksp = 1;
  246.             TelInfo->CONFstate=0;
  247.             break;
  248.  
  249.         case 7:
  250.             setmacro( 0, s);
  251.             TelInfo->CONFstate=0;
  252.             break;
  253.         case 8:
  254.             setmacro( 1, s);
  255.             TelInfo->CONFstate=0;
  256.             break;
  257.         case 9:
  258.             setmacro( 2, s);
  259.             TelInfo->CONFstate=0;
  260.             break;
  261.         case 10:
  262.             setmacro( 3, s);
  263.             TelInfo->CONFstate=0;
  264.             break;
  265.         case 11:
  266.             setmacro( 4, s);
  267.             TelInfo->CONFstate=0;
  268.             break;
  269.         case 12:
  270.             setmacro( 5, s);
  271.             TelInfo->CONFstate=0;
  272.             break;
  273.         case 13:
  274.             setmacro( 6, s);
  275.             TelInfo->CONFstate=0;
  276.             break;
  277.         case 14:
  278.             setmacro( 7, s);
  279.             TelInfo->CONFstate=0;
  280.             break;
  281.         case 15:
  282.             setmacro( 8, s);
  283.             TelInfo->CONFstate=0;
  284.             break;
  285.         case 16:
  286.             setmacro( 9, s);
  287.             TelInfo->CONFstate=0;
  288.             break;
  289.         case 17:
  290.             TelInfo->CONFstate=0;        // Now ignored (was commandkeys)
  291.             break;
  292.         case 18:
  293.             if (!strcmp(s,"backspace") )
  294.                 SetSessionPtr->bksp = 0;
  295.             else
  296.                 SetSessionPtr->bksp = 1;
  297.             TelInfo->CONFstate=0;
  298.             break;
  299.         case 19:
  300.         case 21:
  301.             if ( 1 == sscanf(s,"%d", &a) ) 
  302.                 SetTerminalPtr->vtwidth = a;
  303.             TelInfo->CONFstate=0;
  304.             break;
  305.         case 20:
  306.             if (affirmative(s))
  307.                 SetSessionPtr->tekclear = 1;
  308.             else
  309.                 SetSessionPtr->tekclear = 0;
  310.             TelInfo->CONFstate = 0;
  311.             break;
  312.         case 22:
  313.             if ( 3 != sscanf(s, "{%u,%u,%u}", &a, &b, &c)) {    /* BYU LSC - "%d" changed to "%u" */
  314.                 sets_debug_print("Bad Parms to rgb");
  315.                 return(2);
  316.                 }
  317.             SetTerminalPtr->nfcolor.red = a;
  318.             SetTerminalPtr->nfcolor.green = b;
  319.             SetTerminalPtr->nfcolor.blue = c;
  320.             TelInfo->CONFstate = 0;
  321.             break;            
  322.         case 23:
  323.             if ( 3 != sscanf(s, "{%u,%u,%u}", &a, &b, &c)) {    /* BYU LSC - "%d" changed to "%u" */
  324.                 sets_debug_print("Bad Parms to rgb");
  325.                 return(2);
  326.                 }
  327.             SetTerminalPtr->nbcolor.red = a;
  328.             SetTerminalPtr->nbcolor.green = b;
  329.             SetTerminalPtr->nbcolor.blue = c;
  330.             TelInfo->CONFstate = 0;
  331.             break;            
  332.         case 24:
  333.             if ( 3 != sscanf(s, "{%u,%u,%u}", &a, &b, &c)) {    /* BYU LSC - "%d" changed to "%u" */
  334.                 sets_debug_print("Bad Parms to rgb");
  335.                 return(2);
  336.                 }
  337.             SetTerminalPtr->bfcolor.red = a;
  338.             SetTerminalPtr->bfcolor.green = b;
  339.             SetTerminalPtr->bfcolor.blue = c;
  340.             TelInfo->CONFstate = 0;
  341.             break;            
  342.         case 25:
  343.             if ( 3 != sscanf(s, "{%u,%u,%u}", &a, &b, &c)) {    /* BYU LSC - "%d" changed to "%u" */
  344.                 sets_debug_print("Bad Parms to rgb");
  345.                 return(2);
  346.                 }
  347.             SetTerminalPtr->bbcolor.red = a;
  348.             SetTerminalPtr->bbcolor.green = b;
  349.             SetTerminalPtr->bbcolor.blue = c;
  350.             TelInfo->CONFstate = 0;
  351.             break;
  352.         case 26:        /* Font Name */
  353.             strncpy(tempCstring, s, 63);            /* Move name in */
  354.             CtoPstr(tempCstring);
  355.             BlockMove(tempCstring, &(SetTerminalPtr->DisplayFont[0]), tempCstring[0]+1);
  356.             TelInfo->CONFstate = 0;
  357.             break;
  358.         case 27:        /* Font Size */
  359.             if (1 == sscanf( s, "%d", &a))
  360.                 SetTerminalPtr->fontsize = a;
  361.             TelInfo->CONFstate = 0;
  362.             break;
  363.         case 28:        /* number of lines to use for window's editable region */
  364.             if (1 == sscanf( s, "%d", &a))
  365.                 SetTerminalPtr->vtheight = a;
  366.             TelInfo->CONFstate = 0;
  367.             break;
  368.         case 29:        /* keystop, XOFF key */
  369.             if (1 == sscanf( s, "%d", &a))
  370.                 SetSessionPtr->skey = a;
  371.             TelInfo->CONFstate = 0;
  372.             break;
  373.         case 30:        /* keygo, XON key */
  374.             if (1 == sscanf( s, "%d", &a))
  375.                 SetSessionPtr->qkey = a;
  376.             TelInfo->CONFstate = 0;
  377.             break;
  378.         case 31:        /* keyip, kill key */
  379.             if (1 == sscanf( s, "%d", &a))
  380.                 SetSessionPtr->ckey = a;
  381.             TelInfo->CONFstate = 0;
  382.             break;
  383.         case 32:        /* cr-map */
  384.             if ((1 == sscanf( s, "%d", &a)) && (a !=0))
  385.                 SetSessionPtr->crmap = TRUE;
  386.             else
  387.                 SetSessionPtr->crmap = FALSE;
  388.             TelInfo->CONFstate = 0;
  389.             break;
  390.         case 33:                    /* BYU 2.4.9 */
  391.             if (affirmative(s))        /* BYU 2.4.9 */
  392.                 SetSessionPtr->linemode = TRUE;    /* BYU 2.4.9 */
  393.             else                    /* BYU 2.4.9 */
  394.                 SetSessionPtr->linemode = FALSE;    /* BYU 2.4.9 */
  395.             TelInfo->CONFstate=0;            /* BYU 2.4.9 */
  396.             break;                    /* BYU 2.4.9 */
  397.         case 34:                    /* BYU 2.4.9 */
  398.             if (affirmative(s))        /* BYU 2.4.9 */
  399.                 SetTerminalPtr->eightbit = TRUE;    /* BYU 2.4.9 */
  400.             else                    /* BYU 2.4.9 */
  401.                 SetTerminalPtr->eightbit = FALSE;    /* BYU 2.4.9 */
  402.             TelInfo->CONFstate=0;            /* BYU 2.4.9 */
  403.             break;                    /* BYU 2.4.9 */
  404.         case 35:                    /* BYU */
  405. //            (**SetParams).ftpstate = 1;        /* BYU */
  406.             TelInfo->CONFstate=0;            /* BYU */
  407.             break;                    /* BYU */
  408.         case 36:    // ignored
  409.             TelInfo->CONFstate=0;
  410.             break;
  411.         case PORTNUM:                            /* NCSA 2.5: get the real port # */
  412.             if (1 == sscanf( s, "%d", &a))        /* NCSA */
  413.                 SetSessionPtr->port = a;                /* NCSA */
  414.             TelInfo->CONFstate = 0;                /* NCSA */
  415.             break;                                /* NCSA */
  416.         case 38:    // translation
  417.             strncpy((char *) SetSessionPtr->TranslationTable, s, 32);
  418.             CtoPstr((char *) SetSessionPtr->TranslationTable);
  419.             TelInfo->CONFstate=0;
  420.             break;
  421.         case 39:    // tekem
  422.             if (1 == sscanf(s, "%d", &signedint))
  423.                 SetSessionPtr->tektype = signedint;
  424.             TelInfo->CONFstate=0;
  425.             break;
  426.         case 40:    // answerback
  427.             strncpy((char *) SetTerminalPtr->AnswerBackMessage, s, 32);
  428.             CtoPstr((char *) SetTerminalPtr->AnswerBackMessage);
  429.             TelInfo->CONFstate=0;
  430.             break;
  431.         case 41: //authenticate
  432.             if (affirmative(s))        
  433.                 SetSessionPtr->authenticate = TRUE;
  434.             else                
  435.                 SetSessionPtr->authenticate = FALSE;    
  436.             TelInfo->CONFstate=0;        
  437.             break;
  438.         case 42: //encrypt
  439.             if (affirmative(s))        
  440.                 SetSessionPtr->encrypt = TRUE;    
  441.             else                    
  442.                 SetSessionPtr->encrypt = FALSE;    
  443.             TelInfo->CONFstate=0;            
  444.             break;
  445.         
  446.         case 43: //pageup/down map
  447.             if (affirmative(s))
  448.                 SetTerminalPtr->MATmappings = TRUE;
  449.             else                    
  450.                 SetTerminalPtr->MATmappings = FALSE;    
  451.             break;
  452.         case 44: //keypad map
  453.             if (affirmative(s))
  454.                 SetTerminalPtr->remapKeypad = TRUE;
  455.             else                    
  456.                 SetTerminalPtr->remapKeypad = FALSE;    
  457.             break;
  458.         default:
  459.             TelInfo->CONFstate=0;
  460.         }
  461.     return(0);
  462.   } /* confile */
  463.  
  464. /************************************************************************/
  465. /* contoken
  466. *  tokenize the strings which get passed to confile.
  467. *  Handles quotes and uses separators:  <33, ;:=
  468. */ 
  469. short contoken( char c)
  470. {
  471.     short        retval;
  472.     Boolean        success;
  473.  
  474.     if (c == EOF) {
  475.         Cspace[TelInfo->position++] = '\0';
  476.         sets_debug_print("Eof handler called");
  477.         confile(Cspace);
  478.         if (TelInfo->CONFactive) {
  479.                 success = CreateConnectionFromParams(SetParams);
  480.                 if (!success) {
  481.                     sets_debug_print("ERROR IN OPENING!! ");
  482.                     return(42);
  483.                     }
  484.                 }
  485.         return(-1);
  486.     }
  487.     
  488.     if (!TelInfo->position && !TelInfo->inquote && Sissep(c))
  489.     /*if (!TelInfo->position && Sissep(c))    */    /* old_skip over junk before keyword */
  490.         return(0);
  491.  
  492.     if (TelInfo->inquote || !Sissep(c)) {
  493.  
  494.         if (TelInfo->position > 200) {
  495.             sets_debug_print("Out of bounds error!");
  496.             return(1);
  497.         }
  498. /*
  499. *  check for quotes, a little mixed up here, could be reorganized
  500. */
  501.         if (c == '"' ) {
  502.             if (!TelInfo->inquote) {            /* beginning of quotes */
  503.                 TelInfo->inquote = 1;
  504.                 return(0);
  505.             }
  506.              Cspace[TelInfo->position++] =c;
  507.             return(0);
  508.         }
  509.         else 
  510.             {                        /* include in current string */
  511.             if (c != '\012' && c != '\015')        /* BYU 2.4.18 - changed \n to \015 and added \012 */
  512.                 {
  513.                 Cspace[TelInfo->position++] = c;
  514.                 return(0);
  515.                 }
  516.             }
  517.                 
  518.         }
  519.  
  520.     if (Cspace[TelInfo->position-1] == '"') TelInfo->position--;
  521.     Cspace[TelInfo->position++] = '\0';
  522.  
  523.     retval = confile(Cspace);            /* pass the token along */
  524.  
  525.     TelInfo->position = 0;
  526.     TelInfo->inquote = 0;
  527.     Cspace[0] = '\0';
  528.  
  529.     return(retval);
  530. }
  531.  
  532. /************************************************************************/
  533. /*  readconfig
  534. *   read the saved set file into our in-memory data structure.
  535. *   Handle everything by keyword (stored in resources).
  536. */
  537. void readconfig(FSSpec theSet)
  538. {
  539.     short c,retval;
  540.     short fn;
  541.     OSErr err;
  542.  
  543.     Cspace = myNewPtr(256);                /* BYU LSC - get room for gathering stuff */
  544.  
  545.     SetParams = ReturnDefaultConnInitParams();
  546.     HLockHi((Handle)SetParams);
  547.     HLockHi((Handle)(**SetParams).session);
  548.     SetSessionPtr = *(**SetParams).session;
  549.     HLockHi((Handle)(**SetParams).terminal);
  550.     SetTerminalPtr = *(**SetParams).terminal;
  551.  
  552.     if (NULL == Cspace)                 /* no memory left for the set to load in */
  553.         {                                /* we're out of memory */
  554.         DoError(107 | MEMORY_ERRORCLASS, LEVEL2, NULL);    
  555.         return;
  556.         }
  557.     
  558.     TelInfo->position = TelInfo->CONFstate = TelInfo->CONFactive = TelInfo->inquote = TelInfo->lineno = 0;   /* state vars */    
  559.  
  560.     err = HOpen(theSet.vRefNum, theSet.parID, theSet.name, fsRdPerm, &fn);
  561.  
  562.     retval = 0;
  563.     while (!retval) {
  564.         c = Myfgetc(fn);
  565.         if (c == '#' && !TelInfo->inquote) {
  566.             while (c != EOF && c != '\012' && c != '\015')        /* skip to EOL */    /* BYU 2.4.18 - changed \n to \015 and added \012*/
  567.                 c = Myfgetc(fn);
  568.         }
  569.         if (c == '\012' || c == '\015')            /* BYU 2.4.18 - changed \n to \015 and added \012 */
  570.             TelInfo->lineno++;
  571.         retval = contoken(c);
  572.     }
  573.  
  574.     FSClose(fn);
  575.     DisposPtr((Ptr) Cspace);
  576.  
  577.     if (retval == EOF) {                /* EOF is normal end */
  578.         sets_debug_print("EOF termination");
  579.         }
  580.     else {
  581.         sets_debug_print("NON-EOF termination");
  582.         }
  583.         
  584.     return;
  585. }
  586.  
  587. void LoadSet( void)
  588. {
  589.     SFReply        sfr;
  590.     long        junk;
  591.     SFTypeList    typesok = {'CONF'};
  592.     Point        where;
  593.     FSSpec        set;
  594.     Str255        tempString;
  595.     where.h=100;where.v=100;
  596.  
  597.     GetIndString(tempString,MISC_STRINGS,SET_TO_LOAD_STRING);
  598.     SFGetFile( where,tempString, 0L, 1, typesok, 0L, &sfr);
  599.  
  600.     if (! sfr.good) return;
  601.  
  602.     BlockMove(&sfr.fName, set.name, (*sfr.fName)+1); // pstring copy sfr.fName -> set.name
  603.     GetWDInfo(sfr.vRefNum, &set.vRefNum, &set.parID, &junk);
  604.     readconfig(set);
  605. }
  606.  
  607. char Myfgetc(short myfile)
  608. {
  609.     OSErr err;
  610.     long count;
  611.     unsigned char buffer;
  612.     
  613.     count = 1;
  614.     if ((err = FSRead(myfile, &count, &buffer)) == eofErr)
  615.         buffer = EOF;
  616.     
  617.     return (buffer);
  618. }
  619.  
  620. void CStringToFile(short myfile, unsigned char *mystring) 
  621. {    
  622.     long mycount;                                        /* BYU LSC */
  623.     short fstatus;                                        /* BYU LSC */
  624.   
  625.   mycount = strlen((char *) mystring);                /* BYU LSC */
  626.   fstatus = FSWrite(myfile,&mycount,mystring);        /* BYU LSC */
  627. }
  628.  
  629.  
  630. void SaveSet( void)
  631. {
  632.     SFReply        sfr;
  633.     short        fn, truncate;
  634.     WindowPeek    wpeek;
  635.     Rect        rect;
  636.     Point        where;
  637.     long        junk;
  638.     char        temp[256], temp2[256];            /* BYU LSC */
  639.     short            fnum,fsiz;
  640.     short            i;
  641.     FSSpec        set;
  642.     OSErr        err;
  643.     Str255        scratchPstring,scratchPstring2;
  644.     
  645.     where.h = 100; where.v = 100;
  646.     GetIndString(scratchPstring,MISC_STRINGS,SAVE_SET_STRING);
  647.     GetIndString(scratchPstring2,MISC_STRINGS,DEFAULT_SAVE_SET_NAME);
  648.     SFPutFile(where,scratchPstring,scratchPstring2, 0L, &sfr);    /* BYU LSC */
  649.  
  650.     if (!sfr.good)
  651.         return;
  652.  
  653.     BlockMoveData(&sfr.fName, set.name, (*sfr.fName)+1); // pstring copy sfr.fName -> set.name
  654.     GetWDInfo(sfr.vRefNum, &set.vRefNum, &set.parID, &junk);
  655.  
  656.     if ((err = HCreate(set.vRefNum, set.parID, set.name, kNCSACreatorSignature, kNCSASetFileType)) == dupFNErr)
  657.         truncate = 1;
  658.         
  659.     err = HOpen(set.vRefNum, set.parID, set.name, fsWrPerm, &fn);
  660.  
  661.     if (truncate) 
  662.         SetEOF(fn, 0L);
  663.  
  664.     if (gApplicationPrefs->CommandKeys)
  665.         CStringToFile(fn,(unsigned char *) "commandkeys = yes\015");    /* BYU LSC */
  666.     else
  667.         CStringToFile(fn,(unsigned char *) "commandkeys = no\015");        /* BYU LSC */
  668.  
  669.     for (i = 0; i < 10; i++)
  670.       {
  671.         getmacro(i, temp, sizeof(temp));            /* BYU LSC */
  672.         if (*temp) {                                    /* BYU LSC */
  673.             sprintf(temp2, "key%d = \"", i);            /* BYU 2.4.16 */
  674.             CStringToFile(fn,(unsigned char *) temp2);    /* BYU LSC */
  675.             CStringToFile(fn,(unsigned char *) temp);    /* BYU LSC */
  676.             strcpy(temp2,"\"\015");                        /* BYU LSC */
  677.             CStringToFile(fn,(unsigned char *) temp2);    /* BYU LSC */
  678.         }                                                /* BYU LSC */
  679.       } /* for */
  680.  
  681. #if 0                                                    /* BYU LSC */
  682.     for (i = 0; i < TelInfo->numwindows; i++)
  683.       {
  684.         short j;
  685.         j = RSgetfont(screens[i].vs, &fnum, &fsiz);
  686.       } /* for */
  687. #endif                                                    /* BYU LSC */
  688.  
  689.     for (i = 0; i < TelInfo->numwindows; i++)
  690.       {
  691.           GetWTitle(screens[i].wind, scratchPstring);
  692.           PtoCstr(scratchPstring);
  693.         sprintf(temp2, "name= \"%s\"\015", scratchPstring);
  694.         CStringToFile(fn,(unsigned char *) temp2);                /* BYU LSC */
  695.  
  696.         BlockMove((Ptr)screens[i].machine, (Ptr)scratchPstring, Length(screens[i].machine)+1);
  697.         PtoCstr(scratchPstring);
  698.         sprintf(temp2, "host= \"%s\"\015", scratchPstring);
  699.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  700.  
  701.         sprintf (temp2,"port= %d\015",screens[i].portNum);    /* NCSA: save port # */
  702.         CStringToFile(fn,(unsigned char *) temp2);                        /* BYU LSC */
  703.  
  704.         sprintf(temp2, "scrollback= %d\015", (screens[i].maxscroll));    /* BYU LSC */
  705.         CStringToFile(fn,(unsigned char *) temp2);                        /* BYU LSC */
  706.  
  707.         if (screens[i].bsdel)
  708.             CStringToFile(fn,(unsigned char *)  "erase = delete\015");        /* BYU LSC */
  709.         else
  710.             CStringToFile(fn,(unsigned char *)  "erase = backspace\015");    /* BYU LSC */
  711.  
  712.         wpeek = (WindowPeek) screens[i].wind;
  713.         rect = (*wpeek->contRgn)->rgnBBox;
  714.  
  715.         sprintf(temp2, "size = {%d,%d,%d,%d}\015", rect.top, rect.left,    /* BYU LSC */
  716.                     rect.bottom, rect.right);
  717.         CStringToFile(fn,(unsigned char *) temp2);                        /* BYU LSC */
  718.  
  719.         sprintf(temp2, "vtwidth = %d\015", VSmaxwidth(screens[i].vs) + 1);            /* BYU LSC */
  720.         CStringToFile(fn,(unsigned char *) temp2);                        /* BYU LSC */
  721.  
  722.         if (screens[i].tekclear)
  723.             CStringToFile(fn,(unsigned char *) "tekclear = yes\015");    /* BYU LSC */
  724.         else
  725.             CStringToFile(fn,(unsigned char *) "tekclear = no\015");    /* BYU LSC */
  726.  
  727.         if (TelInfo->haveColorQuickDraw)
  728.         {
  729.             RGBColor theColor;
  730.             short j;
  731.             for (j = 0; j < 4; j++)
  732.             {
  733.                 theColor = RSgetcolor( screens[i].vs, j);
  734.                 sprintf(temp2, "rgb%d = {%u,%u,%u}\015",
  735.                     j, theColor.red, theColor.green, theColor.blue);
  736.                 CStringToFile(fn,(unsigned char *) temp2);
  737.             } 
  738.         } 
  739.         RSgetfont( screens[i].vs, &fnum, &fsiz);
  740.         GetFontName( fnum, (StringPtr)temp);                                    /* BYU LSC */
  741. #ifndef MPW
  742.         p2cstr((unsigned char *) temp);                                /* BYU LSC */
  743. #endif
  744.  
  745.         sprintf( temp2, "font = \"%s\"\015", temp);                    /* BYU LSC */
  746.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  747.         sprintf( temp2, "fsize= %d\015", fsiz);                        /* BYU LSC */
  748.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  749.         
  750.         sprintf( temp2, "nlines= %d\015", VSgetlines(screens[i].vs));/* BYU LSC */
  751.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  752.         sprintf( temp2, "keystop= %d\015", screens[i].TELstop);        /* BYU LSC */
  753.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  754.         sprintf( temp2, "keygo= %d\015", screens[i].TELgo);            /* BYU LSC */
  755.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  756.         sprintf( temp2, "keyip= %d\015", screens[i].TELip);            /* BYU LSC */
  757.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  758.         sprintf( temp2, "crmap= %d\015", screens[i].crmap);        /* BYU LSC */
  759.         CStringToFile(fn,(unsigned char *) temp2);                    /* BYU LSC */
  760.         sprintf( temp2, "tekem= %d\015", screens[i].tektype);
  761.         CStringToFile(fn,(unsigned char *) temp2);
  762.         if (screens[i].national) {                        // Don't do this if using default translation table
  763.             GetItem(myMenus[National], screens[i].national+1, scratchPstring);
  764.             PtoCstr(scratchPstring);
  765.             sprintf(temp2, "translation= \"%s\"\015", scratchPstring);
  766.             CStringToFile(fn, (unsigned char *)temp2);
  767.             }
  768.         BlockMove(screens[i].answerback, scratchPstring, *(screens[i].answerback)+1);
  769.         PtoCstr(scratchPstring);
  770.         sprintf(temp2, "answerback= \"%s\"\015", scratchPstring);
  771.         CStringToFile(fn, (unsigned char *)temp2);
  772.  
  773.         if (screens[i].authenticate)
  774.             CStringToFile(fn,(unsigned char *) "authenticate = yes\015");    //CCP added next four lines for authencrypt
  775.         else
  776.             CStringToFile(fn,(unsigned char *) "authenticate = no\015");    
  777.  
  778.         if (screens[i].encrypt)
  779.             CStringToFile(fn,(unsigned char *) "encrypt = yes\015");    
  780.         else
  781.             CStringToFile(fn,(unsigned char *) "encrypt = no\015");    
  782.  
  783.         if (screens[i].pgupdwn)
  784.             CStringToFile(fn,(unsigned char *) "pageup = yes\015");    //CCP 2.7
  785.         else
  786.             CStringToFile(fn,(unsigned char *) "pageup = no\015");    
  787.  
  788.         if (screens[i].keypadmap)
  789.             CStringToFile(fn,(unsigned char *) "keypad = yes\015");    //CCP 2.7
  790.         else
  791.             CStringToFile(fn,(unsigned char *) "keypad = no\015");    
  792.           
  793.       } /* for i */
  794.  
  795.     FSClose(fn);                        /* BYU LSC */
  796. }
  797.